定义

一个对象应该对其他对象有最小的了解，也就是说，一个类应该对自己需要耦合或者调用的类知道的最少，类的内部如何实现与调用者或者依赖者没关系，调用者或者依赖者只需要知道它需要的方法即可。类和类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响越大。

举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class Room {
    public float area;
    public float price;
    
    public Room(float area, float price) {
        this.area = area;
        this.price = price;
    }
    
    @Override
    public String toString() {
        return "Room [area=" + area + ", price=" + price + "]";
    }
}
public class Mediator {
    List{Room} mRooms = new ArrayList<Room>();
    public Mediator() {
        for (int i = 0; i < 5; i++) {
            mRooms.add(new Room(14 + i, (14 + i) * 150));
        }
    }
    
    public List<Room> getAllRooms() {
        return mRooms;
    }
}
public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = 100.0001f;
    public static final float diffArea = 0.00001f;
    
    public void rentRoom(Mediator mediator) {
        List<Room> rooms = mediator.getAllRooms();
        for (Room room : rooms) {
            if (isSuitable(room)) {
                System.out.println("租到房间啦! " + room);
                break;
            }
        }
    }
    
    private boolean isSuitable(Room room) {
        ...
    }
}

在上面的代码中，Tenant不仅依赖了Mediator类，还需要频繁的与Room类打交道，租户类的要求只是通过中介找到一间合适自己的房间罢了，如果把这些检测条件都放在Tenant类中，那么中介类的功能就被弱化，而且导致Tenant与Room的耦合较高，因为Tenant必须知道关于Room的细节，当Room变化时Tenant也必须跟着变化，Tenant又与Mediator耦合，这个时候就需要分清谁才是真正的朋友。

既然耦合太重，我们就只能解耦了，我们只与Mediator直接通信，不直接操作Room：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Mediator { 
	List<Room> mRooms = new ArrayList<>();
    
    public Mediator() {
        for (int i = 0; i < 5; i++) {
            mRooms.add(new Room(14 + i, (14 + i) * 150));
        }
    }
    
    public Room rentOut(float area, float price) {
        for (Room room : mRooms) {
            if (isSuitable(area, price, room)) {
                return room;
            }
        }
        return null;
    }
    
    private boolean isSuitable(float area, float price, Room room) {
        ...
    }
}
public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = 100.0001f;
    public static final float diffArea = 0.00001f;
    
    public void rentRoom(Mediator mediator) {
        System.out.println("租到房啦 " + mediator.rentOut(roomArea, roomPrice));
    }
}

同样的，在前面几小节中，ImageCache就是用户的直接朋友，而SD卡缓存内部却是使用了DiskLruCache实现，这个DiskLruCache就不属于用户的直接朋友了，因此，用户完全不需要知道它的存在，用户只需要和ImageCache对象打交道。

总之，最重要的还是抽象。